Link Text is one of the Selenium WebDriver locator strategies used to identify and interact with hyperlinks on a web page. It locates an anchor element using the complete visible text displayed to the user. Selenium provides the By.linkText() method for locating a hyperlink by its exact visible text.
Link Text is especially useful when a web page contains meaningful and unique hyperlink text such as Login, Register, Contact Us, Download, or View Details.
For structured Selenium learning, you can explore the JustAcademy's Selenium Training Course and use the Register for Course Demo link for a course demonstration.
Link Text is a Selenium locator used to locate an HTML hyperlink by matching the complete visible text inside an anchor element.
In HTML, hyperlinks are normally created using the <a> tag.
<a href="https://example.com">Login</a>In this example, Login is the visible link text. Selenium can locate this hyperlink using:
driver.findElement(By.linkText("Login"));The important point is that By.linkText() searches for the visible text of an anchor element rather than its ID, class, name, or href attribute.
Web applications contain many hyperlinks that users click to navigate from one page to another. Selenium automation frequently needs to identify these links and perform actions such as clicking them, reading their text, verifying their presence, or checking their destination.
driver.findElement(By.linkText("Link Text")).click();The syntax contains three important parts:
<html>
<body>
<a href="https://example.com/login">Login</a>
<a href="https://example.com/register">Register</a>
<a href="https://example.com/contact">Contact Us</a>
</body>
</html>
The visible link texts are:
They can be located using:
driver.findElement(By.linkText("Login"));
driver.findElement(By.linkText("Register"));
driver.findElement(By.linkText("Contact Us"));
Before using Link Text, Selenium WebDriver must be configured in the Java project.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
A basic WebDriver setup can be written as:
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class LinkTextExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
driver.findElement(By.linkText("More information...")).click();
driver.quit();
}
}
The script opens the website, searches for a hyperlink whose complete visible text is More information..., clicks it, and finally closes the browser.
Link Text primarily works with hyperlink elements represented by the HTML <a> tag.
<a href="https://example.com">Visit Website</a>Here:
| HTML Part | Meaning |
|---|---|
| <a> | Anchor element used to create a hyperlink |
| href | Destination URL |
| Visit Website | Visible link text |
By.linkText() is designed to match the complete visible text of the hyperlink.
<a href="/login">Login</a>Correct:
driver.findElement(By.linkText("Login")).click();An incorrect or incomplete value may not locate the element:
driver.findElement(By.linkText("Log")).click();For partial visible text, Selenium provides By.partialLinkText().
| Feature | Link Text | Partial Link Text |
|---|---|---|
| Method | By.linkText() | By.partialLinkText() |
| Matching | Complete visible text | Part of visible text |
| Example | "Login" | "Log" |
| Precision | More precise | Less precise |
| Best Use | Unique complete link text | Dynamic or long link text |
<a href="/products">View All Products</a>Using complete Link Text:
driver.findElement(By.linkText("View All Products")).click();Using Partial Link Text:
driver.findElement(By.partialLinkText("Products")).click();Both approaches can locate the link, but they use different matching strategies.
The findElement() method is commonly used when one specific hyperlink needs to be located.
WebElement loginLink = driver.findElement(By.linkText("Login"));
loginLink.click();
The WebElement can also be used for validation:
WebElement loginLink = driver.findElement(By.linkText("Login"));
System.out.println(loginLink.getText());
System.out.println(loginLink.isDisplayed());
System.out.println(loginLink.isEnabled());
import org.openqa.selenium.WebElement;A complete example:
WebElement link = driver.findElement(By.linkText("Login"));
link.click();
Selenium provides both findElement() and findElements() for locating web elements.
| Method | Return Type | Use |
|---|---|---|
| findElement() | WebElement | Find one matching element |
| findElements() | List<WebElement> | Find multiple matching elements |
When the requirement is to retrieve all hyperlinks on a page, the a tag can be used.
List<WebElement> links = driver.findElements(By.tagName("a"));Import the List interface:
import java.util.List;Complete example:
List<WebElement> links = driver.findElements(By.tagName("a"));
System.out.println("Total links: " + links.size());
List<WebElement> links = driver.findElements(By.tagName("a"));
for (WebElement link : links) {
System.out.println(link.getText());
}
This technique is useful when testing navigation menus, footer links, product links, or other collections of hyperlinks.
List<WebElement> links = driver.findElements(By.tagName("a"));
for (WebElement link : links) {
if (link.getText().equals("Login")) {
link.click();
break;
}
}
This approach can be useful when the page contains multiple links and you want to inspect their visible text programmatically.
Navigation menus commonly contain links such as Home, About, Services, Courses, Contact, and Login.
<nav>
<a href="/home">Home</a>
<a href="/about">About Us</a>
<a href="/services">Services</a>
<a href="/contact">Contact Us</a>
</nav>
Selenium:
driver.findElement(By.linkText("Home")).click();
driver.findElement(By.linkText("About Us")).click();
driver.findElement(By.linkText("Services")).click();
driver.findElement(By.linkText("Contact Us")).click();
<a href="/login">Login</a>driver.findElement(By.linkText("Login")).click();<a href="/register">Register</a>driver.findElement(By.linkText("Register")).click();<a href="/contact">Contact Us</a>driver.findElement(By.linkText("Contact Us")).click();<a href="/files/report.pdf">Download Report</a>driver.findElement(By.linkText("Download Report")).click();Link Text can therefore be useful for testing download links when the visible text is unique.
<a href="/courses/selenium">Selenium Training</a>driver.findElement(By.linkText("Selenium Training")).click();<a href="/products/laptop">Laptop</a>driver.findElement(By.linkText("Laptop")).click();E-commerce websites often contain links such as View Details.
<a href="/product/101">View Details</a>driver.findElement(By.linkText("View Details")).click();However, if several products have the same visible text, using only Link Text may not be sufficient to identify the correct product.
Consider the following page:
<a href="/product/1">View Details</a>
<a href="/product/2">View Details</a>
<a href="/product/3">View Details</a>
Using:
driver.findElement(By.linkText("View Details")).click();may identify the first matching link rather than the specific product intended by the test.
In such cases, a more specific locator such as CSS Selector or XPath should be considered.
XPath can provide more control when Link Text is not sufficiently specific.
driver.findElement(By.xpath("//a[text()='View Details']")).click();A specific link can be located using additional attributes:
driver.findElement(By.xpath("//a[@href='/product/2' and text()='View Details']")).click();CSS selectors can be used when additional attributes are available.
driver.findElement(By.cssSelector("a[href='/product/2']")).click();CSS Selector is often more appropriate when the visible text is duplicated.
When using Link Text, the text supplied to Selenium should match the visible text expected by the browser.
driver.findElement(By.linkText("Login")).click();Do not assume that changing the capitalization will always produce the same result:
driver.findElement(By.linkText("login")).click();Use the actual visible link text when creating the locator.
Spaces that are part of the visible link text matter.
<a href="/account">My Account</a>Use:
driver.findElement(By.linkText("My Account")).click();A locator that does not match the actual visible text may fail to locate the element.
Some applications contain long hyperlinks.
<a href="/article">Read the complete automation testing guide</a>Complete Link Text:
driver.findElement(By.linkText("Read the complete automation testing guide")).click();If the complete text is dynamic or difficult to maintain, Partial Link Text or another locator may be more practical.
driver.findElement(By.partialLinkText("automation testing")).click();Partial Link Text searches for a portion of the visible link text.
Dynamic applications may generate link text that changes depending on data.
<a href="/user/101">Welcome Manish</a>If the name changes for every test execution, exact Link Text may not be stable.
An alternative can be:
driver.findElement(By.xpath("//a[contains(text(),'Welcome')]")).click();A hyperlink may exist in the DOM but not be visible on the page.
<a href="/admin" style="display:none">Admin</a>Finding the element and interacting with it are different operations. Selenium may locate the element, but an attempt to click an invisible element can fail.
WebElement link = driver.findElement(By.linkText("Login"));
if (link.isDisplayed()) {
System.out.println("Login link is displayed");
}
WebElement link = driver.findElement(By.linkText("Login"));
if (link.isEnabled()) {
System.out.println("Login link is enabled");
}
WebElement link = driver.findElement(By.linkText("Login"));
String text = link.getText();
System.out.println("Link text: " + text);
Although Link Text identifies an element using visible text, the destination URL can be retrieved using the href attribute.
WebElement link = driver.findElement(By.linkText("Login"));
String url = link.getAttribute("href");
System.out.println("URL: " + url);
WebElement link = driver.findElement(By.linkText("Login"));
String actualText = link.getText();
if (actualText.equals("Login")) {
System.out.println("Link text is correct");
} else {
System.out.println("Link text is incorrect");
}
WebElement link = driver.findElement(By.linkText("Login"));
String actualUrl = link.getAttribute("href");
if (actualUrl.equals("https://example.com/login")) {
System.out.println("URL is correct");
}
Link Text can be used with TestNG assertions for automated validation.
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyLoginLink() {
WebElement link = driver.findElement(By.linkText("Login"));
Assert.assertTrue(link.isDisplayed());
Assert.assertEquals(link.getText(), "Login");
}
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class LinkTextTest {
WebDriver driver;
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
}
@Test
public void verifyLink() {
WebElement link = driver.findElement(By.linkText("More information..."));
Assert.assertTrue(link.isDisplayed());
Assert.assertEquals(link.getText(), "More information...");
}
@AfterMethod
public void tearDown() {
driver.quit();
}
}
Modern web applications may load links dynamically. In such situations, explicit waits can improve synchronization.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement link = wait.until(
ExpectedConditions.elementToBeClickable(By.linkText("Login"))
);
link.click();
Required imports:
import java.time.Duration;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
| Exception | Possible Reason |
|---|---|
| NoSuchElementException | Link could not be found |
| ElementClickInterceptedException | Another element is blocking the link |
| ElementNotInteractableException | Link cannot currently be interacted with |
| StaleElementReferenceException | DOM changed after locating the link |
| TimeoutException | Explicit wait condition was not satisfied |
This exception can occur when the specified Link Text does not match any available hyperlink.
driver.findElement(By.linkText("Login")).click();Possible reasons include:
This can occur when another element, such as a popup, overlay, cookie banner, or modal, blocks the hyperlink.
A better approach is usually to handle the blocking element rather than immediately using JavaScript.
If a hyperlink is located inside an iframe, Selenium must switch into the iframe before locating the link.
driver.switchTo().frame("paymentFrame");
driver.findElement(By.linkText("Continue")).click();
driver.switchTo().defaultContent();
For nested iframes, Selenium must switch through the frame hierarchy.
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
driver.findElement(By.linkText("Continue")).click();
driver.switchTo().defaultContent();
Tables often contain links such as View, Edit, Delete, or Details.
<table>
<tr>
<td>John</td>
<td><a href="/edit/1">Edit</a></td>
</tr>
</table>
If the Edit link is unique:
driver.findElement(By.linkText("Edit")).click();<div class="product">
<h2>Laptop</h2>
<a href="/laptop">View Product</a>
</div>
If multiple products have the same link text, XPath can be used to connect the link with the required product.
driver.findElement(
By.xpath("//h2[text()='Laptop']/following-sibling::a[text()='View Product']")
).click();
<footer>
<a href="/privacy">Privacy Policy</a>
<a href="/terms">Terms & Conditions</a>
</footer>
Selenium:
driver.findElement(By.linkText("Privacy Policy")).click();In the Page Object Model, locators are generally kept inside page classes.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
public class LoginPage {
WebDriver driver;
By registerLink = By.linkText("Register");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void clickRegister() {
driver.findElement(registerLink).click();
}
}
This approach keeps locators centralized and makes automation code easier to maintain.
public void clickLinkByText(String text) {
driver.findElement(By.linkText(text)).click();
}
The method can then be reused:
clickLinkByText("Login");
clickLinkByText("Register");
clickLinkByText("Contact Us");
String[] expectedLinks = {
"Home",
"About Us",
"Services",
"Contact Us"
};
for (String linkText : expectedLinks) {
WebElement link = driver.findElement(By.linkText(linkText));
System.out.println(linkText + " is displayed: " + link.isDisplayed());
}
driver.findElement(By.linkText("Products")).click();
Assert.assertTrue(driver.getTitle().contains("Products"));
This verifies both the interaction and the resulting navigation.
Link Text can be used to test navigation flows such as:
Home
↓
Products
↓
Product Details
↓
Cart
↓
Checkout
Each navigation step can be automated and validated using appropriate link locators.
driver.findElement(By.linkText("Login")).click();
driver.findElement(By.id("username")).sendKeys("user");
driver.findElement(By.id("password")).sendKeys("password");
driver.findElement(By.id("loginBtn")).click();
Link Text can therefore be part of larger end-to-end automation flows.
driver.findElement(By.linkText("Register")).click();
driver.findElement(By.id("name")).sendKeys("Test User");
driver.findElement(By.id("email")).sendKeys("[email protected]");
Educational websites frequently use links such as:
These links can be automated using Link Text when the visible text is unique and stable.
| Feature | Link Text | ID |
|---|---|---|
| Target | Visible link text | id attribute |
| Typical Element | <a> | Any HTML element |
| Method | By.linkText() | By.id() |
| Readability | High | High |
| Uniqueness | Depends on visible text | Usually high when ID is unique |
| Feature | Link Text | Name |
|---|---|---|
| Uses | Visible hyperlink text | name attribute |
| Method | By.linkText() | By.name() |
| Common Target | Anchor | Form elements |
| Feature | Link Text | Class Name |
|---|---|---|
| Based On | Visible text | class attribute |
| Method | By.linkText() | By.className() |
| Typical Use | Unique hyperlink | Element with a known class |
CSS selectors can use multiple attributes and structural relationships, while Link Text focuses on visible text.
driver.findElement(By.linkText("Login")).click();CSS alternative:
driver.findElement(By.cssSelector("a[href='/login']")).click();XPath is generally more flexible when a link must be identified based on text plus other attributes or its position in the DOM.
driver.findElement(By.xpath("//a[text()='Login']")).click();Link Text is simpler when the complete visible text uniquely identifies the hyperlink.
<a href="/courses">Selenium Training Course</a>Incorrect:
driver.findElement(By.linkText("Selenium")).click();Correct:
driver.findElement(By.linkText("Selenium Training Course")).click();If only a portion is required, consider:
driver.findElement(By.partialLinkText("Selenium")).click();If a page contains multiple links with the same text, relying only on Link Text may lead to the wrong element being selected.
Use a more specific locator when the link needs to be associated with a particular row, card, product, or section.
Link Text is intended for hyperlinks. A button such as:
<button>Login</button>is not the same as:
<a href="/login">Login</a>For a button, use an appropriate locator such as ID, CSS, XPath, or another suitable strategy.
Suppose the application displays:
<a href="/user">Welcome John</a>and later:
<a href="/user">Welcome Sarah</a>Hardcoding the complete Link Text can make the test unstable. In such situations, a more stable attribute or a carefully designed XPath may be better.
If a popup or cookie banner covers the hyperlink, clicking it may fail. The automation should first handle the popup when appropriate.
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class NavigationTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://example.com");
driver.findElement(By.linkText("More information...")).click();
System.out.println(driver.getTitle());
driver.quit();
}
}
List<WebElement> links = driver.findElements(By.tagName("a"));
for (WebElement link : links) {
String text = link.getText();
String href = link.getAttribute("href");
System.out.println("Text: " + text);
System.out.println("URL: " + href);
}
WebElement link = driver.findElement(By.linkText("Login"));
if (link.isDisplayed() && link.isEnabled()) {
link.click();
}
WebElement link = driver.findElement(By.linkText("Login"));
String expectedUrl = "https://example.com/login";
String actualUrl = link.getAttribute("href");
if (expectedUrl.equals(actualUrl)) {
System.out.println("Destination URL is correct");
} else {
System.out.println("Destination URL is incorrect");
}
List<WebElement> links = driver.findElements(By.tagName("a"));
for (WebElement link : links) {
if (link.getText().equals("Login")) {
link.click();
break;
}
}
| Scenario | Example Link | Testing Action |
|---|---|---|
| Login | Login | Click and verify login page |
| Registration | Register | Open registration form |
| Navigation | Products | Verify products page |
| Download | Download Report | Verify download behavior |
| Support | Contact Us | Open contact page |
| Course | Selenium Training | Open course details |
| Purpose | Syntax |
|---|---|
| Locate by complete text | By.linkText("Login") |
| Locate by partial text | By.partialLinkText("Log") |
| Click link | driver.findElement(By.linkText("Login")).click() |
| Store link | WebElement link = driver.findElement(By.linkText("Login")); |
| Get text | link.getText() |
| Get destination | link.getAttribute("href") |
Link Text is a Selenium locator strategy used to locate a hyperlink based on its complete visible text. Selenium provides the By.linkText() method for this purpose.
driver.findElement(By.linkText("Login")).click();Partial Link Text locates an anchor element using a portion of its visible text.
driver.findElement(By.partialLinkText("Login")).click();| Link Text | Partial Link Text |
|---|---|
| Matches complete visible text | Matches a portion of visible text |
| More precise | More flexible |
| By.linkText() | By.partialLinkText() |
No. Link Text is intended for hyperlink elements. A button should generally be located using an appropriate attribute-based, CSS, XPath, or other supported locator strategy.
If multiple elements match the same locator, findElement() returns the first matching element in the current search context. To identify a particular link, use a more specific locator or narrow the search context.
Use a stable attribute when available. Otherwise, carefully designed XPath or Partial Link Text may be used when it produces a unique and stable match.
WebElement link = driver.findElement(By.linkText("Login"));
Assert.assertEquals(link.getText(), "Login");
WebElement link = driver.findElement(By.linkText("Login"));
String url = link.getAttribute("href");
List<WebElement> links = driver.findElements(By.tagName("a"));Yes. Link Text locators can be declared as fields inside Page Object classes.
By loginLink = By.linkText("Login");Link Text can become unstable when the visible text is changed frequently, localized into different languages, generated dynamically, or duplicated across the page.
Applications supporting multiple languages may display different link text depending on the selected language.
English: Login
French: Connexion
Spanish: Iniciar sesión
A test that depends on exact English text may fail when the application language changes. In such cases, language-independent attributes or other stable locators may be preferable.
Meaningful link text also helps users understand where a hyperlink leads. Automation testers should prefer clear, stable link text when designing or validating test scenarios.
A locator is maintainable when it remains valid despite unrelated UI changes. If a link's visible text changes frequently, relying exclusively on Link Text can increase maintenance effort.
Modern web applications frequently update content without a complete page refresh. A link may be created after JavaScript execution or an API response. Explicit waits and stable locator strategies should be used when necessary.
Need to locate a hyperlink
↓
Is the complete visible text unique and stable?
↓
Yes
↓
Use By.linkText()
↓
No
↓
Is partial text stable and unique?
↓
Yes
↓
Use By.partialLinkText()
↓
No
↓
Use a stable ID, CSS Selector, or XPath
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement loginLink = wait.until(
ExpectedConditions.elementToBeClickable(By.linkText("Login"))
);
Assert.assertEquals(loginLink.getText(), "Login");
loginLink.click();
This example combines a readable locator, explicit wait, text validation, and interaction.
Consider an e-commerce application containing the following navigation:
Home
Products
Categories
Offers
Login
Register
Contact Us
A Selenium test can verify that the important navigation links are available.
String[] navigationLinks = {
"Home",
"Products",
"Categories",
"Offers",
"Login",
"Register",
"Contact Us"
};
for (String text : navigationLinks) {
WebElement link = driver.findElement(By.linkText(text));
System.out.println(text + ": " + link.isDisplayed());
}
A reusable link validation framework can perform the following operations:
Open Browser
↓
Navigate to Application
↓
Identify Required Hyperlink
↓
Use By.linkText()
↓
Wait for Element
↓
Verify Visibility
↓
Verify Link Text
↓
Click Link
↓
Validate Destination
↓
Generate Test Result
↓
Close Browser
| Locator | Method | Typical Usage |
|---|---|---|
| ID | By.id() | Unique element ID |
| Name | By.name() | name attribute |
| Class Name | By.className() | class attribute |
| Tag Name | By.tagName() | HTML tag |
| Link Text | By.linkText() | Complete hyperlink text |
| Partial Link Text | By.partialLinkText() | Partial hyperlink text |
| CSS Selector | By.cssSelector() | CSS-based selection |
| XPath | By.xpath() | Advanced element selection |
| Question | Answer |
|---|---|
| What is Link Text? | A locator strategy for finding hyperlinks by complete visible text. |
| Method? | By.linkText() |
| Partial text method? | By.partialLinkText() |
| Typical HTML element? | <a> |
| Can it locate buttons? | No, it is intended for links. |
| What if links have duplicate text? | Use a more specific locator. |
| How to get href? | getAttribute("href") |
| How to get visible text? | getText() |
Link Text is a simple and readable Selenium locator strategy for identifying hyperlinks through their complete visible text. It is particularly useful for navigation links, login links, registration links, course links, download links, and other hyperlinks whose text is unique and stable.
The basic syntax is:
driver.findElement(By.linkText("Login")).click();When the complete text is not suitable, By.partialLinkText(), CSS Selector, XPath, ID, or another stable locator can be used depending on the structure of the application.
For professional Selenium automation, Link Text should be combined with proper waits, validation, Page Object Model practices, reusable utilities, and stable locator strategies.
For further Selenium learning and practical automation training, visit the JustAcademy's Selenium Training Course or use the Register for Course Demo link.
